package com.example.bledemo.ui;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.widget.ContentFrameLayout;

import android.app.ProgressDialog;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.MotionEvent;
import android.view.GestureDetector;
import android.view.WindowManager;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

import com.bumptech.glide.Glide;
import com.bumptech.glide.request.target.SimpleTarget;
import com.bumptech.glide.request.transition.Transition;

import com.example.bledemo.R;
import com.example.bledemo.bean.BaseData;
import com.example.bledemo.bean.LocationData;
import com.example.bledemo.bean.MapListData;
import com.example.bledemo.bean.PointListData;
import com.example.bledemo.net.ApiCallback;
import com.example.bledemo.net.ApiHelper;
import com.example.bledemo.net.RetrofitClient;
import com.example.bledemo.tool.Algorithm;
import com.example.bledemo.tool.Point;
import com.example.bledemo.ui.view.MyMapPointView;
import com.example.bledemo.ui.view.MyMapPointWithTitleView;
import com.example.bledemo.ui.view.MyMapView;
import com.example.bledemo.util.IpSettingsManager;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

import okhttp3.OkHttpClient;
import okhttp3.Request;


public class MapActivity extends BaseActivity {
    private String TAG = "MapActivity";
    private ProgressDialog progressDialog;

    private String labelID;
    private MyMapPointWithTitleView myMapPointWithTitleView;
    private MyMapPointWithTitleView longPoint;
    private Algorithm ar;
    private Point startPoint;
    private MyMapView myMapView;

    // 新增的UI组件
    private Spinner mapSpinner;
    private TextView mapNameText;
    private TextView mapInfoText;
    private Button retryButton;

    // 侧边栏相关组件
    private LinearLayout sidebarLayout;
    private LinearLayout sidebarContent;
    private View sidebarOverlay;
    private Button currentLocationButton;
    private List<PointListData.PointData> pointDataList;
    private Map<Integer, List<PointListData.PointData>> groupedPoints;
    private boolean isSidebarVisible = false;
    private PointListData.PointData selectedPoint = null;
    private Map<PointListData.PointData, View> pointItemViews = new HashMap<>();

    // 手势检测相关
    private GestureDetector gestureDetector;
    private float startX, startY;
    private static final float SWIPE_THRESHOLD = 50f; // 降低滑动阈值
    private static final float SWIPE_VELOCITY_THRESHOLD = 50f; // 降低速度阈值

    // 地图数据
    private List<MapListData.MapData> mapDataList;
    private MapListData.MapData currentMapData;
    private boolean isInitializing = true;
    private int retryCount = 0;
    private static final int MAX_RETRY_COUNT = 3;

    // 导航相关
    private Button stopNavigationButton;
    private Timer navigationTimer;
    private boolean isNavigating = false;
    private Point destinationPoint;
    private MyMapPointWithTitleView currentLocationView;

    // 长按加点相关
    private List<MyMapPointWithTitleView> longPressPoints = new ArrayList<>();
    private int longPressPointCounter = 1;

    @Override
    protected int getLayoutId() {
        return R.layout.activity_map;
    }

    @Override
    protected void initViews() {
        ar = new Algorithm();
        myMapView = (MyMapView) findViewById(R.id.myMapView);
        mapSpinner = (Spinner) findViewById(R.id.mapSpinner);
        mapNameText = (TextView) findViewById(R.id.mapNameText);
        mapInfoText = (TextView) findViewById(R.id.mapInfoText);
        retryButton = (Button) findViewById(R.id.retryButton);

        // 初始化侧边栏组件
        sidebarLayout = (LinearLayout) findViewById(R.id.sidebarLayout);
        sidebarContent = (LinearLayout) findViewById(R.id.sidebarContent);
        sidebarOverlay = findViewById(R.id.sidebarOverlay);
        currentLocationButton = (Button) findViewById(R.id.currentLocationButton);
        sidebarOverlay.setAlpha(0f); // 初始化透明度为0

        // 初始化停止导航按钮
        stopNavigationButton = new Button(this);
        stopNavigationButton.setText("停止导航");
        stopNavigationButton.setBackgroundColor(android.graphics.Color.parseColor("#FF5722"));
        stopNavigationButton.setTextColor(android.graphics.Color.WHITE);
        stopNavigationButton.setPadding(20, 10, 20, 10);
        stopNavigationButton.setVisibility(View.GONE);

        // 设置停止导航按钮点击事件
        stopNavigationButton.setOnClickListener(v -> {
            stopNavigation();
        });

        // 将停止导航按钮添加到布局中（左上角）
        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
                RelativeLayout.LayoutParams.WRAP_CONTENT,
                RelativeLayout.LayoutParams.WRAP_CONTENT
        );
        params.addRule(RelativeLayout.ALIGN_PARENT_TOP);
        params.addRule(RelativeLayout.ALIGN_PARENT_START);
        params.setMargins(16, 16, 0, 0);
        stopNavigationButton.setLayoutParams(params);

        ((ContentFrameLayout) findViewById(android.R.id.content)).addView(stopNavigationButton);

        // 确保侧边栏初始状态正确
        sidebarLayout.setTranslationX(-280);
        sidebarLayout.setVisibility(View.GONE);

        pointDataList = new ArrayList<>();
        groupedPoints = new HashMap<>();

        // 初始化手势检测器
        initGestureDetector();


        // 初始隐藏下拉栏和信息显示区域
        mapSpinner.setVisibility(View.GONE);
        mapNameText.setVisibility(View.GONE);
        mapInfoText.setVisibility(View.GONE);
        retryButton.setVisibility(View.GONE);

        // 设置重试按钮点击事件
        retryButton.setOnClickListener(v -> {
            if (currentMapData != null) {
                loadSelectedMap(currentMapData);
            }
        });

        // 不直接设置地图的触摸事件，而是通过手势检测器来处理
        // 让MyMapView保持原有的触摸事件处理

        // 设置覆盖层点击事件
        sidebarOverlay.setOnClickListener(v -> {
            if (isSidebarVisible) {
                hideSidebar();
            }
        });

        // 设置当前位置按钮点击事件
        currentLocationButton.setOnClickListener(v -> {
            Log.d(TAG, "当前位置按钮被点击");
            getNowLocation();
        });

        // 添加一个测试按钮来显示侧边栏
        Button testButton = new Button(this);
        testButton.setText("显示点位");
        testButton.setOnClickListener(v -> {
            if (pointDataList != null && !pointDataList.isEmpty()) {
                showSidebar();
            } else {
                showToast("没有点位数据");
            }
        });

        // 添加手势测试按钮
        Button gestureTestButton = new Button(this);
        gestureTestButton.setText("测试手势");
        gestureTestButton.setOnClickListener(v -> {
            showToast("从左边缘向右滑动可以打开侧边栏");
            Log.d(TAG, "手势测试按钮被点击");
        });

        // 添加调试按钮
        Button debugButton = new Button(this);
        debugButton.setText("调试信息");
        debugButton.setOnClickListener(v -> {
            String debugInfo = "侧边栏状态: " + isSidebarVisible +
                    "\n点位数据数量: " + (pointDataList != null ? pointDataList.size() : 0) +
                    "\n手势检测器: " + (gestureDetector != null ? "已初始化" : "未初始化");
            showToast(debugInfo);
            Log.d(TAG, debugInfo);
        });

        myMapView.setMapOnLongClickListener(new MyMapView.MyMapViewOnLongClickListener() {
            @Override
            public void myMapViewOnLongClick(float downX, float downY) {
                addLongPressPoint(downX, downY);
            }
        });

    }

    //获取所有的Point
    private void getPointList(Long mapID) {
        //获取标签当前定位
        ApiHelper.request(
                RetrofitClient.getApiService().getPointList(mapID),
                new ApiCallback<PointListData>() {
                    @Override
                    public void onSuccess(PointListData data) {
                        Log.d(TAG, "getPointList:" + data);
                        if (data.getData() != null && data.getData().getList() != null) {
                            Log.d(TAG, "Point列表数量: " + data.getData().getList().size());
                            pointDataList = data.getData().getList();
                            hideConnectionDialog();
                            groupPointsByType();

//                            showSidebar();
                        } else {
                            Log.d(TAG, "Point列表数据为空");
                            pointDataList = new ArrayList<>(); // 初始化为空列表
                            groupPointsByType();
//                            showSidebar(); // 即使没有数据也显示侧边栏
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.d(TAG, "getPointList:" + t.toString());
                        pointDataList = new ArrayList<>(); // 初始化为空列表
                        groupPointsByType();
                        showSidebar(); // 即使网络请求失败也显示侧边栏
                        showToast("获取点位数据失败: " + t.getMessage());
                    }
                }
        );
    }

    @Override
    protected void initData() {
        Bundle extras = getIntent().getExtras();
        if (extras != null) {
            labelID = extras.getString("labelID");
        }
        Log.d(TAG, "labelID:" + labelID);

        //获取地图数据
        ApiHelper.request(
                RetrofitClient.getApiService().getMapList(),
                new ApiCallback<MapListData>() {
                    @Override
                    public void onSuccess(MapListData data) {
                        Log.d(TAG, "getMapList:" + data);
                        if (data != null && data.getData() != null) {

                            mapDataList = data.getData();
                            Log.d(TAG, "地图数据数量: " + mapDataList.size());
                            for (int i = 0; i < data.getData().size(); i++) {
                                Log.d(TAG, "getMapList:" + data.getData().get(i));
                            }
                            // 初始化下拉栏
                            initMapSpinner();
                        } else {
                            Log.e(TAG, "getMapList错误:" + data.getMessage());
                            hideConnectionDialog();
                            showToast("获取地图列表失败: " + data.getMessage());
                            // 显示UI组件，即使没有数据
                            showUIComponents();
                        }
                    }


                    @Override
                    public void onError(Throwable t) {
                        Log.d(TAG, "getMapList:" + t.toString());
                        hideConnectionDialog();
                        showToast("获取地图列表失败: " + t.getMessage());
                        // 显示UI组件，即使网络请求失败
                        showUIComponents();
                    }
                }
        );
    }

    private void getNowLocation() {
        Log.d(TAG, "开始获取当前位置");
        showConnectionDialog("获取位置", "正在获取当前位置...");

        ApiHelper.request(
                RetrofitClient.getApiService().getNowLocation(labelID),
                new ApiCallback<LocationData>() {
                    @Override
                    public void onSuccess(LocationData data) {
                        Log.d(TAG, "获取标签当前定位:" + data);
                        if (data.getData() != null) {
                            Log.d(TAG, "用MAPid获取地图:" + data.getData().getMapId());
                            startPoint = new Point((int) data.getData().getXaxis(), (int) data.getData().getYaxis());

                            // 获取地图ID
                            long mapId = data.getData().getMapId();

                            // 查找对应的地图数据
                            MapListData.MapData targetMapData = findMapDataById(mapId);
                            if (targetMapData != null) {
                                // 切换到对应的地图
                                switchToMap(targetMapData);
                            } else {
                                Log.w(TAG, "未找到对应的地图数据，mapId: " + mapId);
                                hideConnectionDialog();
                                showToast("未找到对应的地图数据");
                            }
                        } else {
                            Log.d(TAG, "标签定位数据为空");
                            hideConnectionDialog();
                            showToast("标签定位数据为空");
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.d(TAG, "NewLocation:" + t.toString());
                        hideConnectionDialog();
                        showToast("获取位置失败: " + t.getMessage());
                    }
                }
        );
    }

    /**
     * 初始化地图下拉栏
     */
    private void initMapSpinner() {
        Log.d(TAG, "initMapSpinner 开始执行");
        if (mapDataList == null || mapDataList.isEmpty()) {
            Log.d(TAG, "地图数据为空");
            showToast("没有可用的地图数据");
            hideConnectionDialog();
            showUIComponents(); // 显示UI组件，即使没有数据
            return;
        }

        // 创建地图名称列表
        List<String> mapNames = new ArrayList<>();
        mapNames.add("请选择地图"); // 添加默认选项
        for (MapListData.MapData mapData : mapDataList) {
            mapNames.add(mapData.getMapName());
        }

        // 设置适配器
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
                android.R.layout.simple_spinner_item, mapNames) {
            @Override
            public android.view.View getView(int position, android.view.View convertView, android.view.ViewGroup parent) {
                android.view.View view = super.getView(position, convertView, parent);
                if (view instanceof android.widget.TextView) {
                    android.widget.TextView textView = (android.widget.TextView) view;
                    if (position == 0) {
                        textView.setTextColor(android.graphics.Color.parseColor("#999999")); // 默认选项使用灰色
                    } else {
                        textView.setTextColor(android.graphics.Color.parseColor("#2196F3")); // 使用蓝色
                    }
                    textView.setTextSize(15);
                    textView.setSingleLine(true);
                    textView.setEllipsize(android.text.TextUtils.TruncateAt.END);
                }
                return view;
            }

            @Override
            public android.view.View getDropDownView(int position, android.view.View convertView, android.view.ViewGroup parent) {
                android.view.View view = super.getDropDownView(position, convertView, parent);
                if (view instanceof android.widget.TextView) {
                    android.widget.TextView textView = (android.widget.TextView) view;
                    if (position == 0) {
                        textView.setTextColor(android.graphics.Color.parseColor("#999999")); // 默认选项使用灰色
                    } else {
                        textView.setTextColor(android.graphics.Color.parseColor("#333333")); // 下拉选项使用黑色
                    }
                    textView.setTextSize(15);
                    textView.setPadding(20, 16, 20, 16);
                    textView.setSingleLine(true);
                    textView.setEllipsize(android.text.TextUtils.TruncateAt.END);
                }
                return view;
            }
        };
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        mapSpinner.setAdapter(adapter);


        // 设置选择监听器
        mapSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
            @Override
            public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
                if (!isInitializing && position > 0 && position <= mapDataList.size()) {
                    currentMapData = mapDataList.get(position - 1); // 减1是因为添加了默认选项
                    loadSelectedMap(currentMapData);
                }
            }

            @Override
            public void onNothingSelected(AdapterView<?> parent) {
                // 不做任何处理
            }
        });

        // 设置初始选择为第一个有图片路径的地图
        if (!mapDataList.isEmpty()) {
            // 查找第一个有图片路径的地图
            MapListData.MapData firstValidMap = null;
            int firstValidIndex = -1;
            for (int i = 0; i < mapDataList.size(); i++) {
                MapListData.MapData mapData = mapDataList.get(i);
                if (mapData.getImage() != null && !mapData.getImage().isEmpty()) {
                    firstValidMap = mapData;
                    firstValidIndex = i;
                    break;
                }
            }

            // 如果没有找到有图片的地图，使用第一个地图
            if (firstValidMap == null) {
                firstValidMap = mapDataList.get(0);
                firstValidIndex = 0;
            }

            currentMapData = firstValidMap;
            // 先设置选择，再加载地图，避免触发选择事件
            mapSpinner.setSelection(firstValidIndex + 1); // +1 因为有默认选项
            loadSelectedMap(currentMapData);
        }

        // 显示下拉栏和信息显示区域
        Log.d(TAG, "设置UI组件可见");
        mapSpinner.setVisibility(View.VISIBLE);
        mapNameText.setVisibility(View.VISIBLE);
        mapInfoText.setVisibility(View.VISIBLE);
        retryButton.setVisibility(View.GONE); // 初始时隐藏重试按钮


        // 强制刷新布局
        mapSpinner.requestLayout();
        mapSpinner.invalidate();

        // 设置初始化完成
        isInitializing = false;

        // 隐藏连接对话框
        hideConnectionDialog();
    }

    /**
     * 显示UI组件
     */
    private void showUIComponents() {

        mapSpinner.setVisibility(View.VISIBLE);
        mapNameText.setVisibility(View.VISIBLE);
        mapInfoText.setVisibility(View.VISIBLE);

        // 如果没有数据，显示提示信息
        if (mapDataList == null || mapDataList.isEmpty()) {
            Log.d(TAG, "显示无数据提示");
            mapNameText.setText("地图名称: 无可用地图");
            mapInfoText.setText("请检查网络连接或联系管理员");
        } else {
            Log.d(TAG, "显示地图数据，数量: " + mapDataList.size());
            // 如果有数据，显示第一个地图的信息
            if (mapDataList.size() > 0) {
                displayMapInfo(mapDataList.get(0));
            }
        }
    }

    /**
     * 加载选中的地图
     */
    private void loadSelectedMap(MapListData.MapData mapData) {
        if (mapData == null) {
            showToast("地图数据为空");
            return;
        }

        // 显示地图信息
        displayMapInfo(mapData);

        // 只有当图片路径不为空时才下载地图
        if (mapData.getImage() != null && !mapData.getImage().isEmpty()) {
            downloadAndLoadMap(mapData.getImage());
        } else {
            showToast("地图图片路径为空，无法下载地图");
        }
    }

    /**
     * 显示地图信息
     */
    private void displayMapInfo(MapListData.MapData mapData) {
        Log.d(TAG, "displayMapInfo 被调用，地图名称: " + mapData.getMapName());
        mapNameText.setText("🗺️ " + mapData.getMapName());

        String info = String.format("📋 地图ID: %s\n📏 比例: %.3f\n🏗️ 层级: %d\n📍 基准点: (%d, %d)\n📅 创建时间: %s",
                mapData.getId(),
                mapData.getRation(),
                mapData.getMapLevel(),
                mapData.getBasePosX(),
                mapData.getBasePosY(),
                mapData.getCreateTime());

        // 只有当图片路径不为空时才显示
        if (mapData.getImage() != null && !mapData.getImage().isEmpty()) {
            info += "\n🖼️ 图片路径: " + mapData.getImage();
        } else {
            info += "\n⚠️ 图片路径: 未设置";
        }

        mapInfoText.setText(info);
        retryButton.setVisibility(View.GONE);

        // 更新下拉栏显示
        if (mapDataList != null && !mapDataList.isEmpty()) {
            int index = mapDataList.indexOf(mapData);
            if (index >= 0) {
                mapSpinner.setSelection(index + 1); // +1 因为有默认选项
            }
        }
    }

    /**
     * 使用Glide下载并加载地图
     */
    private void downloadAndLoadMap(String imagePath) {
        String baseUrl = IpSettingsManager.getBaseUrl(this);

        // 处理图片路径，确保正确拼接
        String processedPath = imagePath;
        if (processedPath.startsWith("/")) {
            processedPath = processedPath.substring(1);
        }

        String downUrl = baseUrl + processedPath;

        Log.d(TAG, "下载地图URL: " + downUrl);

        // 显示加载对话框
        showConnectionDialog("下载地图", "正在下载地图，请稍后。。。");

        // 使用Glide加载图片
        Glide.with(this)
                .asBitmap()
                .load(downUrl)
                .timeout(60000) // 60秒超时
                .into(new SimpleTarget<Bitmap>() {
                    @Override
                    public void onResourceReady(@NonNull Bitmap bitmap, @Nullable Transition<? super Bitmap> transition) {
                        Log.d(TAG, "Glide加载地图成功，尺寸: " + bitmap.getWidth() + "x" + bitmap.getHeight());

                        runOnUiThread(() -> {
                            hideConnectionDialog();
                            retryCount = 0; // 重置重试计数

                            // 清理之前的UI元素
                            myMapView.clearMapLines();
                            myMapView.clearMapPoints();
                            myMapView.clearAnimation();

                            // 设置地图到MyMapView
                            myMapView.setMapState(bitmap, bitmap.getWidth(), bitmap.getHeight());

                            // 标记起始点
                            if (startPoint != null) {
                                addStartPoint(startPoint);
                            }

                            if(sidebarLayout.isShown()){
                                sidebarLayout.setVisibility(View.GONE);
                            }
                            showToast("地图加载成功");
                        });
                    }

                    @Override
                    public void onLoadFailed(@Nullable android.graphics.drawable.Drawable errorDrawable) {
                        Log.d(TAG, "Glide加载地图失败");
                        runOnUiThread(() -> {
                            hideConnectionDialog();

                            // 自动重试
                            if (retryCount < MAX_RETRY_COUNT) {
                                retryCount++;
                                showToast("下载失败，正在重试 (" + retryCount + "/" + MAX_RETRY_COUNT + ")");
                                loadSelectedMap(currentMapData);
                            } else {
                                retryCount = 0;
                                showToast("下载地图失败: 网络连接异常");
                                retryButton.setVisibility(View.VISIBLE);
                            }
                        });
                    }
                });
    }

    /**
     * 获取地图url
     */
    private void getMapURL(long mapID) {
        // 获取寻路文件URL
        ApiHelper.request(
                RetrofitClient.getApiService().getMapFile(mapID),
                new ApiCallback<BaseData>() {

                    @Override
                    public void onSuccess(BaseData data) {
                        Log.d(TAG, "获取寻路文件URL:" + data);
                        if (data != null && data.getData() != null && !data.getData().isEmpty()) {
                            //开始下载地图文件
                            downLoadMap(data.getData());
                        } else {
                            Log.e(TAG, "寻路文件URL为空:");
                            // 安全地返回上一页面
                            safeFinish("寻路文件URL为空");
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.d(TAG, "getMapFile:" + t.toString());
                        // 安全地返回上一页面
                        safeFinish("获取地图文件失败: " + t.getMessage());
                    }
                }
        );
    }


    private String fileNamestring = "";

    /**
     * 开始下载地图
     */
    private void downLoadMap(String url) {
        String baseUrl = IpSettingsManager.getBaseUrl(this);
        // 修复：使用类成员变量而不是局部变量
        this.fileNamestring = url.split("/")[3];
        Log.d(TAG, "提取的文件名: " + this.fileNamestring);
//        if (baseUrl.endsWith("/") && url.startsWith("/")){
//            url.substring(1);
//        }
        String downUrl = baseUrl + url.substring(1);
        Log.d(TAG, "使用下载URL: " + downUrl);
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(downUrl)
                .build();
        client.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(okhttp3.Call call, IOException e) {
                Log.d(TAG, "下载文件请求失败：" + e);
                runOnUiThread(() -> {
                    showToast("下载文件失败: " + e.getMessage());
                });
            }

            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException {
                if (!response.isSuccessful() || response.body() == null) {
                    Log.d(TAG, "下载文件响应无效: " + response.code());
                    runOnUiThread(() -> {
                        showToast("下载文件失败: 服务器返回错误码 " + response.code());
                    });
                    return;
                }

                Log.d(TAG, "下载文件请求成功，开始保存文件");
                // 获取文件数据
                InputStream inputStream = response.body().byteStream();
                // 保存文件到本地
                saveFile(inputStream, fileNamestring);
            }
        });
    }

    private void saveFile(InputStream inputStream, String fileName) {
        Log.d(TAG, "saveFile");
        File file = new File(this.getExternalFilesDir(null), fileName);

        Log.d(TAG, "文件Environment2: " + file.getName());
        try (FileOutputStream outputStream = new FileOutputStream(file)) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }

            Log.d(TAG, "文件下载成功: " + file.getAbsolutePath());

//            // 在主线程通知用户
//            runOnUiThread(() -> {
//                showToast("地图文件下载成功");
//                // 标记起始点
//                if (startPoint != null) {
//                    addStartPoint(startPoint);
//                }
//            });

            // 初始化地图
            ar.initMap(file);
        } catch (IOException e) {
            Log.d(TAG, "文件下载失败: " + file.getAbsolutePath() + ":" + e);
            e.printStackTrace();

            // 在主线程通知用户
            runOnUiThread(() -> {
                showToast("地图文件下载失败: " + e.getMessage());
            });
        }
    }

    private void addStartPoint(Point point) {
        Log.d(TAG, "标记起始点：" + point.X + " y:" + point.Y);

        // 清除之前的起始点
        if (myMapPointWithTitleView != null) {
            myMapView.removeView(myMapPointWithTitleView);
        }

        // 创建新的起始点
        myMapPointWithTitleView = new MyMapPointWithTitleView(this, point.X, point.Y, MyMapPointView.BLUE_POINT, true, "📍 当前位置");

        // 设置导航监听器
        myMapPointWithTitleView.setOnNavigationListener(new MyMapPointWithTitleView.OnNavigationListener() {
            @Override
            public void onNavigate(String pointTitle, double x, double y) {
//                Log.d(TAG, "导航到: " + pointTitle + " 坐标: (" + x + ", " + y + ")");
                showToast("起始点，无须导航 ");
                // 这里可以添加实际的导航逻辑
                // 例如：调用路径规划算法、显示路径等
            }
        });

        myMapView.addMapPoint(myMapPointWithTitleView);
        hideConnectionDialog();
        Log.d(TAG, "起始点已添加到地图");
    }


    /**
     * 显示连接对话框
     */
    private void showConnectionDialog(String title, String message) {
        progressDialog = new ProgressDialog(this);
        progressDialog.setTitle(title);
        progressDialog.setMessage(message);
        progressDialog.setCancelable(false);
        progressDialog.show();
    }

    /**
     * 隐藏连接对话框
     */
    private void hideConnectionDialog() {
        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
    }

    /**
     * 初始化手势检测器
     */
    private void initGestureDetector() {
        gestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {
            @Override
            public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                if (e1 == null || e2 == null) return false;

                float diffX = e2.getX() - e1.getX();
                float diffY = e2.getY() - e1.getY();

                Log.d(TAG, "手势检测: diffX=" + diffX + ", diffY=" + diffY +
                        ", velocityX=" + velocityX + ", startX=" + e1.getX());

                // 检查是否是水平滑动
                if (Math.abs(diffX) > Math.abs(diffY)) {
                    // 从左往右滑动（打开侧边栏）- 只在屏幕左边缘检测
                    if (diffX > SWIPE_THRESHOLD && velocityX > SWIPE_VELOCITY_THRESHOLD && e1.getX() < 100) {
                        Log.d(TAG, "检测到从左往右滑动，尝试打开侧边栏");
                        if (!isSidebarVisible) {
                            showSidebar();
                            return true;
                        } else {
                            Log.d(TAG, "侧边栏状态: " + isSidebarVisible + ", 点位数据: " +
                                    (pointDataList != null ? pointDataList.size() : 0));
                        }
                    }
                    // 从右往左滑动（关闭侧边栏）
                    else if (diffX < -SWIPE_THRESHOLD && velocityX < -SWIPE_VELOCITY_THRESHOLD) {
                        Log.d(TAG, "检测到从右往左滑动，尝试关闭侧边栏");
                        if (isSidebarVisible) {
                            hideSidebar();
                            return true;
                        }
                    }
                }

                return false;
            }

            @Override
            public boolean onDown(MotionEvent e) {
                startX = e.getX();
                startY = e.getY();
                return false; // 不消费DOWN事件，让地图可以正常处理
            }
        });
    }

    /**
     * 按类型分组点位数据
     */
    private void groupPointsByType() {
        groupedPoints.clear();
        if (pointDataList != null && !pointDataList.isEmpty()) {
            for (PointListData.PointData point : pointDataList) {
                int type = point.getType();
                if (!groupedPoints.containsKey(type)) {
                    groupedPoints.put(type, new ArrayList<>());
                }
                groupedPoints.get(type).add(point);
            }
            Log.d(TAG, "点位数据分组完成，共 " + groupedPoints.size() + " 个分类");
        } else {
            Log.d(TAG, "点位数据为空，无法分组");
        }
    }

    /**
     * 显示侧边栏
     */
    private void showSidebar() {
        if (isSidebarVisible) return;

        Log.d(TAG, "显示侧边栏，点位数量: " + (pointDataList != null ? pointDataList.size() : 0));

        sidebarContent.removeAllViews();
        pointItemViews.clear();

        // 检查是否有点位数据
        if (pointDataList != null && !pointDataList.isEmpty() && !groupedPoints.isEmpty()) {
            // 按类型显示点位
            for (Map.Entry<Integer, List<PointListData.PointData>> entry : groupedPoints.entrySet()) {
                int type = entry.getKey();
                List<PointListData.PointData> points = entry.getValue();

                // 添加分类标题
                addCategoryTitle(type, points.size());

                // 添加该分类下的所有点位
                for (PointListData.PointData point : points) {
                    addPointItem(point);
                }
            }
        } else {
            // 没有点位数据时显示提示信息
            TextView noDataText = new TextView(this);
            noDataText.setText("暂无点位数据");
            noDataText.setTextColor(android.graphics.Color.parseColor("#666666"));
            noDataText.setTextSize(16);
            noDataText.setGravity(android.view.Gravity.CENTER);
            noDataText.setPadding(0, 40, 0, 40);
            sidebarContent.addView(noDataText);

            Log.d(TAG, "没有点位数据，显示提示信息");
        }

        // 显示侧边栏并添加动画
        sidebarLayout.setVisibility(View.VISIBLE);
        sidebarOverlay.setVisibility(View.VISIBLE);
        sidebarOverlay.animate().alpha(1f).setDuration(300).start();

        sidebarLayout.animate()
                .translationX(0)
                .setDuration(300)
                .withEndAction(new Runnable() {
                    @Override
                    public void run() {
                        isSidebarVisible = true;
                        Log.d(TAG, "侧边栏已显示");
                    }
                })
                .start();
    }

    /**
     * 隐藏侧边栏
     */
    private void hideSidebar() {
        Log.d(TAG, "隐藏侧边栏");
        isSidebarVisible = false;

        // 添加隐藏动画
        sidebarOverlay.animate().alpha(0f).setDuration(300).start();

        sidebarLayout.animate()
                .translationX(-280)
                .setDuration(300)
                .withEndAction(new Runnable() {
                    @Override
                    public void run() {
                        sidebarLayout.setVisibility(View.GONE);
                        sidebarOverlay.setVisibility(View.GONE);
                        Log.d(TAG, "侧边栏已完全隐藏，地图可以正常操作");
                    }
                })
                .start();
    }

    /**
     * 添加分类标题
     */
    private void addCategoryTitle(int type, int count) {
        TextView titleView = new TextView(this);
        titleView.setText(getTypeName(type) + " (" + count + ")");
        titleView.setTextColor(android.graphics.Color.parseColor("#666666"));
        titleView.setTextSize(14);
        titleView.setPadding(0, 16, 0, 8);
        titleView.setBackgroundColor(android.graphics.Color.parseColor("#E0E0E0"));
        titleView.setPadding(16, 8, 16, 8);
        sidebarContent.addView(titleView);
    }

    /**
     * 添加点位项目
     */
    private void addPointItem(PointListData.PointData point) {
        View itemView = getLayoutInflater().inflate(R.layout.item_sidebar_point, null);

        // 设置颜色圆点
        View colorDot = itemView.findViewById(R.id.colorDot);
        int color = getPointColor(point.getType());
        colorDot.setBackgroundTintList(android.content.res.ColorStateList.valueOf(color));

        // 设置点位名称
        TextView pointName = itemView.findViewById(R.id.pointName);
        pointName.setText(point.getName());

        // 设置点位类型
        TextView pointType = itemView.findViewById(R.id.pointType);
        pointType.setText(point.getTypeName());

        // 保存itemView引用
        pointItemViews.put(point, itemView);

        // 设置点击事件
        itemView.setOnClickListener(v -> {
            if (selectedPoint == point) {
                // 再次点击已选择的点位，重新开始导航
                Log.d(TAG, "重新开始导航到: " + point.getName());

                // 检查是否正在导航
                if (isNavigating) {
                    showToast("请先停止当前导航");
                    return;
                }

                // 重新添加点位到地图并开始导航
                addPointToMap(point);
                itemView.setBackgroundColor(android.graphics.Color.parseColor("#E3F2FD"));
                hideSidebar();

                // 触发导航（通过点击地图上的点位）
                // 这里我们需要模拟点击地图上的点位来开始导航
                showToast("请点击地图上的点位开始导航");
            } else {
                // 选择新的点位
                if (selectedPoint != null) {
                    // 清除之前的选择状态
                    View previousView = pointItemViews.get(selectedPoint);
                    if (previousView != null) {
                        previousView.setBackgroundColor(android.graphics.Color.TRANSPARENT);
                    }
                    clearMapPoints();
                }
                selectedPoint = point;
                addPointToMap(point);
                itemView.setBackgroundColor(android.graphics.Color.parseColor("#E3F2FD"));
                hideSidebar();
            }
        });

        sidebarContent.addView(itemView);
    }

    /**
     * 获取点位颜色
     */
    private int getPointColor(int type) {
        switch (type) {
            case 1: // 出入口
                return android.graphics.Color.parseColor("#FF5722"); // 红色
            case 2: // 楼梯
                return android.graphics.Color.parseColor("#4CAF50"); // 绿色
            case 3: // 电梯
                return android.graphics.Color.parseColor("#FF9800"); // 橙色
            case 4: // 普通区域
                return android.graphics.Color.parseColor("#2196F3"); // 蓝色
            default:
                return android.graphics.Color.parseColor("#9E9E9E"); // 灰色
        }
    }

    /**
     * 获取类型名称
     */
    private String getTypeName(int type) {
        switch (type) {
            case 1:
                return "出入口";
            case 2:
                return "楼梯";
            case 3:
                return "电梯";
            case 4:
                return "普通区域";
            default:
                return "其他";
        }
    }

    private List<Point> pointList;

    /**
     * 添加点位到地图
     */
    private void addPointToMap(PointListData.PointData point) {
        // 清除之前的线和点位（但保留起始点）
        myMapView.clearMapLines();

        // 只清除非起始点的点位
        myMapView.clearMapPoints();

        // 重新添加起始点（如果存在）
        if (myMapPointWithTitleView != null) {
            myMapView.addMapPoint(myMapPointWithTitleView);
        }

        // 重新添加长按点位
        for (MyMapPointWithTitleView longPressPoint : longPressPoints) {
            myMapView.addMapPoint(longPressPoint);
        }

        Log.d(TAG, "添加点位到地图: " + point.getName() + " 坐标: (" + point.getX() + ", " + point.getY() + ")");

        // 创建点位视图
        MyMapPointWithTitleView pointView = new MyMapPointWithTitleView(
                this,
                point.getX(),
                point.getY(),
                getPointViewType(point.getType()),
                true, // 显示标题
                point.getName()
        );

        // 设置导航监听器
        pointView.setOnNavigationListener(new MyMapPointWithTitleView.OnNavigationListener() {
            @Override
            public void onNavigate(String pointTitle, double x, double y) {
                Log.d(TAG, "开始导航到: " + pointTitle + " 坐标: (" + x + ", " + y + ") 文件名: " + fileNamestring);

                // 检查文件名是否为空或无效
                if (fileNamestring == null || fileNamestring.isEmpty()) {
                    showToast("地图文件未加载，请稍后再试");
                    Log.e(TAG, "文件名为空，无法进行路径规划");
                    return;
                }

                // 从文件名中提取mapId（去掉扩展名）
                String mapId;
                int lastDotIndex = fileNamestring.lastIndexOf('.');
                if (lastDotIndex > 0) {
                    mapId = fileNamestring.substring(0, lastDotIndex);
                } else {
                    // 如果没有扩展名，直接使用文件名
                    mapId = fileNamestring;
                }

                Log.d(TAG, "使用mapId: " + mapId + " 进行路径规划" + "startPoint:" + startPoint + "end:" + new Point(point.getX(), point.getY()));

                // 检查地图数据是否已加载
                if (ar.dl_map.get(mapId) == null) {
                    showToast("地图数据未加载，请稍后再试");
                    Log.e(TAG, "地图数据未找到，mapId: " + mapId);
                    return;
                }

                // 设置目标点
                destinationPoint = new Point(point.getX(), point.getY());

                // 开始导航
                startNavigation(pointTitle, mapId);
            }
        });

        // 添加到地图
        myMapView.addMapPoint(pointView);

        showToast("已标注点位: " + point.getName());
    }

    private void getStartPoint() {
        Log.d(TAG, "获取起始点位置");

        ApiHelper.request(
                RetrofitClient.getApiService().getNowLocation(labelID),
                new ApiCallback<LocationData>() {
                    @Override
                    public void onSuccess(LocationData data) {
                        if (data.getData() != null) {
                            startPoint = new Point((int) data.getData().getXaxis(), (int) data.getData().getYaxis());
                            Log.d(TAG, "起始点位置更新: (" + startPoint.X + ", " + startPoint.Y + ")");
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "获取起始点位置失败: " + t.getMessage());
                        hideConnectionDialog();
                    }
                }
        );
    }

    /**
     * 获取点位视图类型
     */
    private int getPointViewType(int type) {
        switch (type) {
            case 1: // 出入口
                return MyMapPointView.RED_POINT;
            case 2: // 楼梯
                return MyMapPointView.BLACK_POINT; // 使用黑色图标
            case 3: // 电梯
                return MyMapPointView.GRAY_POINT; // 使用灰色图标
            case 4: // 普通区域
                return MyMapPointView.BLUE_POINT;
            default:
                return MyMapPointView.DEFAULT_POINT;
        }
    }

    /**
     * 清除地图上的点
     */
    private void clearMapPoints() {
        Log.d(TAG, "清除地图上的点位");
        
        // 先清除所有点位
        myMapView.clearMapPoints();
        myMapView.clearMapLines();

        // 重新添加起始点（如果存在）
        if (myMapPointWithTitleView != null) {
            myMapView.addMapPoint(myMapPointWithTitleView);
        }

        // 重新添加长按点位
        for (MyMapPointWithTitleView longPressPoint : longPressPoints) {
            myMapView.addMapPoint(longPressPoint);
        }

        showToast("已清除点位标注");
    }

    /**
     * 根据地图ID查找地图数据
     */
    private MapListData.MapData findMapDataById(long mapId) {
        if (mapDataList == null) {
            return null;
        }

        for (MapListData.MapData mapData : mapDataList) {
            if (Long.valueOf(mapData.getId()) == mapId) {
                return mapData;
            }
        }
        return null;
    }

    /**long
     * 切换到指定地图
     */
    private void switchToMap(MapListData.MapData mapData) {
        Log.d(TAG, "切换到地图: " + mapData.getMapName());

        // 更新当前地图数据
        currentMapData = mapData;

        // 更新下拉栏选择
        if (mapDataList != null && !mapDataList.isEmpty()) {
            int index = mapDataList.indexOf(mapData);
            if (index >= 0) {
                mapSpinner.setSelection(index + 1); // +1 因为有默认选项
            }
        }

        // 显示地图信息
        displayMapInfo(mapData);

        // 先隐藏当前位置的dialog
        hideConnectionDialog();

        // 延迟执行其他操作，避免dialog冲突
        new android.os.Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                // 下载地图文件（用于算法初始化）
                getMapURL(Long.valueOf(mapData.getId()));

                // 下载地图图片
                if (mapData.getImage() != null && !mapData.getImage().isEmpty()) {
                    downloadAndLoadMap(mapData.getImage());
                }

                // 获取该地图的点位数据
                getPointList(Long.valueOf(mapData.getId()));

                // 注意：起始点会在downloadAndLoadMap成功后自动添加，这里不需要重复添加
            }
        }, 500); // 延迟500毫秒执行

        showToast("已切换到地图: " + mapData.getMapName());
    }


    /**
     * 安全地结束Activity
     */
    private void safeFinish(String message) {
        try {
            // 隐藏对话框
            hideConnectionDialog();

            // 设置返回结果
            Intent resultData = new Intent();
            resultData.putExtra("key", message);
            setResult(RESULT_OK, resultData);

            // 显示提示信息
            showToast("标签定位失败: " + message);

            // 延迟一点时间再结束，确保提示信息显示
            new android.os.Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    try {
                        finish();
                    } catch (Exception e) {
                        Log.e(TAG, "结束Activity时发生异常: " + e.getMessage());
                    }
                }
            }, 1000); // 延迟1秒

        } catch (Exception e) {
            Log.e(TAG, "safeFinish发生异常: " + e.getMessage());
            // 如果出现异常，直接结束
            try {
                finish();
            } catch (Exception ex) {
                Log.e(TAG, "强制结束Activity时发生异常: " + ex.getMessage());
            }
        }
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        // 在Activity级别处理手势检测
        if (!isSidebarVisible) {
            boolean gestureHandled = gestureDetector.onTouchEvent(ev);
            if (gestureHandled) {
                Log.d(TAG, "手势检测器处理了触摸事件");
                return true;
            }
        }

        // 让子View正常处理触摸事件
        return super.dispatchTouchEvent(ev);
    }

    /**
     * 开始导航
     */
    private void startNavigation(String destinationTitle, String mapId) {
        if (isNavigating) {
            Log.d(TAG, "导航已在进行中");
            showToast("导航已在进行中，请先停止当前导航");
            return;
        }

        Log.d(TAG, "开始导航到: " + destinationTitle);
        isNavigating = true;

        // 显示停止导航按钮
        stopNavigationButton.setVisibility(View.VISIBLE);

        // 禁用其他UI交互
        disableUIInteraction();

        // 清除之前的路径和点位
        myMapView.clearMapLines();
        myMapView.clearMapPoints();

        // 开始定时获取位置
        startLocationTimer(mapId);

        showToast("开始导航到: " + destinationTitle);
    }

    /**
     * 停止导航
     */
    private void stopNavigation() {
        Log.d(TAG, "停止导航");
        isNavigating = false;

        // 隐藏停止导航按钮
        stopNavigationButton.setVisibility(View.GONE);

        // 启用其他UI交互
        enableUIInteraction();

        // 停止定时器
        stopLocationTimer();

        // 只清除导航路径，保留用户选择的点位
        myMapView.clearMapLines();

        // 重新添加用户选择的点位（如果存在）
        if (selectedPoint != null) {
            addPointToMap(selectedPoint);
        }

        // 标注当前位置
        markCurrentLocation();

        showToast("导航已停止");
    }

    /**
     * 开始位置定时器
     */
    private void startLocationTimer(String mapId) {
        if (navigationTimer != null) {
            navigationTimer.cancel();
        }

        navigationTimer = new Timer();
        navigationTimer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                if (isNavigating) {
                    updateLocationAndPath(mapId);
                }
            }
        }, 0, 3000); // 每3秒更新一次位置
    }

    /**
     * 停止位置定时器
     */
    private void stopLocationTimer() {
        if (navigationTimer != null) {
            navigationTimer.cancel();
            navigationTimer = null;
        }
    }

    /**
     * 更新位置和路径
     */
    private void updateLocationAndPath(String mapId) {
        Log.d(TAG, "更新位置和路径");

        // 获取当前位置
        ApiHelper.request(
                RetrofitClient.getApiService().getNowLocation(labelID),
                new ApiCallback<LocationData>() {
                    @Override
                    public void onSuccess(LocationData data) {
                        if (data.getData() != null && isNavigating) {
                            Point newStartPoint = new Point((int) data.getData().getXaxis(), (int) data.getData().getYaxis());
                            startPoint = newStartPoint;

                            Log.d(TAG, "当前位置更新: (" + newStartPoint.X + ", " + newStartPoint.Y + ")");

                            // 重新计算路径
                            if (destinationPoint != null) {
                                List<Point> newPath = ar.startPlan(newStartPoint, destinationPoint, mapId);

                                runOnUiThread(() -> {
                                    if (newPath != null && newPath.size() > 0) {
                                        // 清除之前的路径
                                        myMapView.clearMapLines();

                                        // 绘制新路径
                                        for (int i = 0; i < newPath.size(); i++) {
                                            Point p = newPath.get(i);
                                            myMapView.addMapLine(p.Y, p.X);
                                        }

                                        // 添加终点标记
                                        Point endPoint = newPath.get(newPath.size() - 1);
                                        MyMapPointWithTitleView endPointView = new MyMapPointWithTitleView(
                                                MapActivity.this, endPoint.Y, endPoint.X, MyMapPointView.RED_POINT, true, "🎯 终点"
                                        );
                                        myMapView.addMapPoint(endPointView);

                                        // 更新当前位置标记
                                        updateCurrentLocationMarker(newStartPoint);

                                        // 检查是否到达目的地
                                        checkDestinationReached(newStartPoint);

                                        myMapView.invalidate();
                                    } else {
                                        Log.w(TAG, "无法找到可行路径");
                                        showToast("无法找到可行路径");
                                    }
                                });
                            }
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "获取位置失败: " + t.getMessage());
                        if (isNavigating) {
                            runOnUiThread(() -> {
                                showToast("获取位置失败，请检查网络连接");
                            });
                        }
                    }
                }
        );
    }

    /**
     * 更新当前位置标记
     */
    private void updateCurrentLocationMarker(Point location) {
        // 移除之前的当前位置标记
        if (currentLocationView != null) {
            myMapView.removeView(currentLocationView);
        }

        // 创建新的当前位置标记
        currentLocationView = new MyMapPointWithTitleView(
                this, location.X, location.Y, MyMapPointView.BLUE_POINT, true, "📍 当前位置"
        );

        // 设置导航监听器（当前位置不需要导航功能）
        currentLocationView.setOnNavigationListener(new MyMapPointWithTitleView.OnNavigationListener() {
            @Override
            public void onNavigate(String pointTitle, double x, double y) {
                showToast("当前位置，无须导航");
            }
        });

        myMapView.addMapPoint(currentLocationView);
    }

    /**
     * 检查是否到达目的地
     */
    private void checkDestinationReached(Point currentLocation) {
        if (destinationPoint != null) {
            // 计算距离（简单的欧几里得距离）
            double distance = Math.sqrt(
                    Math.pow(currentLocation.X - destinationPoint.X, 2) +
                            Math.pow(currentLocation.Y - destinationPoint.Y, 2)
            );

            // 如果距离小于阈值（比如10个单位），认为到达目的地
            if (distance < 10) {
                Log.d(TAG, "已到达目的地，距离: " + distance);
                runOnUiThread(() -> {
                    showToast("🎉 已到达目的地！");
                    stopNavigation();
                });
            }
        }
    }

    /**
     * 标注当前位置
     */
    private void markCurrentLocation() {
        Log.d(TAG, "标注当前位置");

        // 获取当前位置
        ApiHelper.request(
                RetrofitClient.getApiService().getNowLocation(labelID),
                new ApiCallback<LocationData>() {
                    @Override
                    public void onSuccess(LocationData data) {
                        if (data.getData() != null) {
                            Point currentLocation = new Point((int) data.getData().getXaxis(), (int) data.getData().getYaxis());
                            startPoint = currentLocation;

                            runOnUiThread(() -> {
                                // 只添加起始点，不清除其他点位
                                addStartPoint(currentLocation);
                            });
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "获取当前位置失败: " + t.getMessage());
                        runOnUiThread(() -> {
                            showToast("获取当前位置失败");
                        });
                    }
                }
        );
    }

    /**
     * 禁用UI交互
     */
    private void disableUIInteraction() {
        // 禁用地图选择器
        mapSpinner.setEnabled(false);

        // 禁用当前位置按钮
        currentLocationButton.setEnabled(false);

        // 禁用侧边栏
        sidebarLayout.setEnabled(false);

        // 禁用地图视图的触摸事件（可选，如果需要的话）
        // myMapView.setEnabled(false);
    }

    /**
     * 启用UI交互
     */
    private void enableUIInteraction() {
        // 启用地图选择器
        mapSpinner.setEnabled(true);

        // 启用当前位置按钮
        currentLocationButton.setEnabled(true);

        // 启用侧边栏
        sidebarLayout.setEnabled(true);

        // 启用地图视图的触摸事件
        // myMapView.setEnabled(true);
    }

    /**
     * 添加长按点位
     */
    private void addLongPressPoint(float x, float y) {
        Log.d(TAG, "添加长按点位，坐标: (" + x + ", " + y + ")");
        
        // 创建长按点位
        MyMapPointWithTitleView longPressPoint = new MyMapPointWithTitleView(
                this, 
                x, 
                y, 
                MyMapPointView.RED_POINT, 
                true, 
                "添加点 " + longPressPointCounter
        );

        // 设置点击事件，覆盖默认的导航对话框
        longPressPoint.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 显示自定义操作对话框
                showPointActionDialog(longPressPoint, longPressPoint.getTitle(), longPressPoint.getFirstX(), longPressPoint.getFirstY());
            }
        });

        // 添加到地图
        myMapView.addMapPoint(longPressPoint);
        
        // 保存到列表
        longPressPoints.add(longPressPoint);
        
        // 更新计数器
        longPressPointCounter++;
        
        showToast("已添加点位: " + "添加点 " + longPressPointCounter);
        Log.d(TAG, "长按点位已添加: " + "添加点 " + longPressPointCounter + " 坐标: (" + x + ", " + y + ")");
    }

    /**
     * 显示点位操作对话框
     */
    private void showPointActionDialog(MyMapPointWithTitleView pointView, String pointTitle, double pointX, double pointY) {
        android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(this);
        builder.setTitle("点位操作");
        builder.setMessage("请选择对点位 \"" + pointTitle + "\" 的操作");

        // 设置对话框按钮 - 左边清除，右边导航
        builder.setNegativeButton("清除", new android.content.DialogInterface.OnClickListener() {
            @Override
            public void onClick(android.content.DialogInterface dialog, int which) {
                // 清除点位
                removeLongPressPoint(pointView);
                dialog.dismiss();
            }
        });

        builder.setPositiveButton("导航", new android.content.DialogInterface.OnClickListener() {
            @Override
            public void onClick(android.content.DialogInterface dialog, int which) {
                // 开始导航
                startNavigationToLongPressPoint(pointTitle, pointX, pointY);
                dialog.dismiss();
            }
        });

        // 显示对话框
        android.app.AlertDialog dialog = builder.create();
        dialog.show();
    }

    /**
     * 移除长按点位
     */
    private void removeLongPressPoint(MyMapPointWithTitleView pointView) {
        Log.d(TAG, "移除长按点位");
        
        // 从地图上移除
        myMapView.removeView(pointView);
        
        // 从列表中移除
        longPressPoints.remove(pointView);
        
        showToast("已清除点位");
        Log.d(TAG, "长按点位已移除");
    }

    /**
     * 开始导航到长按点位
     */
    private void startNavigationToLongPressPoint(String pointTitle, double pointX, double pointY) {
        Log.d(TAG, "开始导航到长按点位: " + pointTitle + " 坐标: (" + pointX + ", " + pointY + ")");

        // 检查文件名是否为空或无效
        if (fileNamestring == null || fileNamestring.isEmpty()) {
            showToast("地图文件未加载，请稍后再试");
            Log.e(TAG, "文件名为空，无法进行路径规划");
            return;
        }

        // 从文件名中提取mapId（去掉扩展名）
        String mapId;
        int lastDotIndex = fileNamestring.lastIndexOf('.');
        if (lastDotIndex > 0) {
            mapId = fileNamestring.substring(0, lastDotIndex);
        } else {
            // 如果没有扩展名，直接使用文件名
            mapId = fileNamestring;
        }

        Log.d(TAG, "使用mapId: " + mapId + " 进行路径规划" + "startPoint:" + startPoint + "end:" + new Point((int)pointX, (int)pointY));

        // 检查地图数据是否已加载
        if (ar.dl_map.get(mapId) == null) {
            showToast("地图数据未加载，请稍后再试");
            Log.e(TAG, "地图数据未找到，mapId: " + mapId);
            return;
        }

        // 设置目标点
        destinationPoint = new Point((int) pointX, (int) pointY);

        // 开始导航
        startNavigation(pointTitle, mapId);
    }

    /**
     * 清除所有长按点位
     */
    private void clearAllLongPressPoints() {
        Log.d(TAG, "清除所有长按点位");
        
        // 从地图上移除所有长按点位
        for (MyMapPointWithTitleView pointView : longPressPoints) {
            myMapView.removeView(pointView);
        }
        
        // 清空列表
        longPressPoints.clear();
        
        // 重置计数器
        longPressPointCounter = 1;
        
        showToast("已清除所有长按点位");
        Log.d(TAG, "所有长按点位已清除");
    }

    /**
     * 获取长按点位统计信息
     */
    private String getLongPressPointsInfo() {
        return "长按点位数量: " + longPressPoints.size();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 清理资源
        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
        progressDialog = null;

        // 停止导航定时器
        stopLocationTimer();
    }
}